package com.lyf.language.learn.atsgg.java8.functional;

import org.junit.Test;

import java.util.*;
import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.function.Supplier;

/**
 * @AUTHOR LYF
 * @DATE 2022/6/6
 * @VERSION 1.0
 * @DESC
 */
public class FunctionInterfaceTests {
    @Test
    public void test1(){
//        new FunctionInterface(){
//            @Override
//            public void test() {
//
//            }
//        }.test2();

//        new FunctionInterface(){
//            @Override
//            public void test() {
//                System.out.println("hello");
//            }
//        };
//        Comparator , Runnable



    }
    /**
     * 尚硅谷举例--
     * Comparator 有参 ,Runnable--空参
     */
    @Test
    public void test2(){
        // ---------------------空参类-------------------------
        Runnable runnable1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("running ....");
            }
        };
        runnable1.run();

        Runnable runnable2 = () -> System.out.println("running ....");
        runnable2.run();

        //-------------------------------------------------

        // 若接口中有多个抽象---则不能lambda替代---,函数不唯一，无法表示---
        // new 接口---理解：必须实现抽象方法 等价于 实现了其继承子类？
        Interface1 interface1 = new Interface1() {
            @Override
            public void test1() {
                System.out.println("interface1..");
            }

            @Override
            public void test2() {
                System.out.println("interface2..");
            }
        };
        interface1.test1();

        //------------------------------------------------

        Abstract1 abstract1 = new Abstract1() {
            @Override
            void test1() {

            }

            @Override
            void test2() {

            }
        };

        //------------------------------------------------

        Comparator<Integer> comparator1 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(o1,o2);
            }
        };

        System.out.println(comparator1.compare(2,1));

        Comparator<Integer> comparator2 = (o1, o2) -> Integer.compare(o1,o2);
        System.out.println(comparator2.compare(2,1));

        Comparator<Integer> comparator3 = Integer::compare;
        System.out.println(comparator3.compare(2,1));






    }
    /**
     * 六种情况：× 无参、一参、多参 *（返回、无返回）
     * （1）无参无返回 Runnable
     * （2）有一参无返回 Consumer
     * （3）有一参有返回
     * →→（从参数列表、方法体 等角度进行思考）
     *  形式一：无参无返回 Runnable
     *  形式二：有一参无返回 Consumer
     *  形式三：类型推断  Class<T>  c   =（T t)->{}   （）中的T有 前面的类已经决定，无需再写--可类型推断
     *  类型推断其他示例：ArrayList<Integer> list  = new ArrayList<>();int []arr ={1,23}
     *  形式四：若参数只有一个，小括号可以省略
     *  形式五：多参、多执行，有返回值
     *  形式六：执行体，只有一个语句---return和大括号可省略
     */
    @Test
    public void test3(){}

    /**
     * Consumer
     */
    @Test
    public void test4()
    {
        Consumer<String> consumer = (str)-> System.out.println(str);
        consumer.accept("hello");
        Supplier<String> supplier =()->{
            return "hello";
        };
        //supplier.get();
    }
    @Test
    public void test5(){
          List<String> list0 = Arrays.asList("南京", "东京","天津");
          // 传递函数--传递逻辑--当逻辑（不同的判断条件）复用变动抽离出来时，考虑--
          List<String> list1 = filterList(list0,(s)->s.contains("京"));
          List<String> list2 = filterList(list0,(s)->s.contains("东"));
          list1.forEach(System.out::println);
          list2.forEach(System.out::println);

          // 推送的判断逻辑还可以单独拎出来

        Predicate<Integer> predicate1 = (i)->{
          return true;
        };

        pushMsg(1,(i)->{
              if(i==0)
                  return true;
              //CusUserBean user = WebSocketServer.getUserMap().get(token);
//                    // 遍历的同时,用户掉线?
//                    if (user != null && user.getDeptId()==(receiveDeptId)) {
//                        System.out.println(user.getUsername()+"---"+user.getDeptId()+"---"+receiveDeptId);
//                        WebSocketServer.sendInfo("1", token);
//                    }
              return false;
          });

    }
    public List<String> filterList(List<String> list, Predicate<String> t){
        ArrayList<String> list1 = new ArrayList<>();
        for(String s:list){
            if(t.test(s)){// 思考直接采用--equals呢？--不够灵活需要在此处去修改使用逻辑，而每个的判断方法不同，则-复用性不好，--将判断逻辑抽离出来
                list1.add(s);
            }
        };
        return list1;
    }
    // 模拟
    List<String> list = new LinkedList<>();
    public void pushMsg(Integer id,Predicate<Integer> predicate){
        for(String str:list){
            if(predicate.test(id)){
                //sendInfo....通过才发送消息
            }
        }
    }

    // 改写---
//    public void pushMessage(Integer receiveDeptId) {
//        if (receiveDeptId == 0) {
//            for (String token : WebSocketServer.getWebSocketMap().keySet()) {
//                try {
//                    WebSocketServer.sendInfo("1", token);
//                } catch (IOException e) {
//                    e.printStackTrace();
//                }
//            }
//        } else {
//            for (String token : WebSocketServer.getWebSocketMap().keySet()) {
//                try {
//                    CusUserBean user = WebSocketServer.getUserMap().get(token);
//                    // 遍历的同时,用户掉线?
//                    if (user != null && user.getDeptId()==(receiveDeptId)) {
//                        System.out.println(user.getUsername()+"---"+user.getDeptId()+"---"+receiveDeptId);
//                        WebSocketServer.sendInfo("1", token);
//                    }
//                } catch (IOException e) {
//                    e.printStackTrace();
//                }
//            }
//        }
//    }




}
